<!DOCTYPE html>

<html xmlns="http://www.w3.org/1999/xhtml">

<head>

<meta charset="utf-8" />
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<meta name="generator" content="pandoc" />




<title>关联规则</title>

<script src="1-apriori_files/jquery-1.11.3/jquery.min.js"></script>
<meta name="viewport" content="width=device-width, initial-scale=1" />
<link href="1-apriori_files/bootstrap-3.3.5/css/united.min.css" rel="stylesheet" />
<script src="1-apriori_files/bootstrap-3.3.5/js/bootstrap.min.js"></script>
<script src="1-apriori_files/bootstrap-3.3.5/shim/html5shiv.min.js"></script>
<script src="1-apriori_files/bootstrap-3.3.5/shim/respond.min.js"></script>
<script src="1-apriori_files/jqueryui-1.11.4/jquery-ui.min.js"></script>
<link href="1-apriori_files/tocify-1.9.1/jquery.tocify.css" rel="stylesheet" />
<script src="1-apriori_files/tocify-1.9.1/jquery.tocify.js"></script>
<script src="1-apriori_files/navigation-1.1/tabsets.js"></script>
<script src="1-apriori_files/navigation-1.1/codefolding.js"></script>


<style type="text/css">code{white-space: pre;}</style>
<style type="text/css">
div.sourceCode { overflow-x: auto; }
table.sourceCode, tr.sourceCode, td.lineNumbers, td.sourceCode {
  margin: 0; padding: 0; vertical-align: baseline; border: none; }
table.sourceCode { width: 100%; line-height: 100%; background-color: #f8f8f8; }
td.lineNumbers { text-align: right; padding-right: 4px; padding-left: 4px; color: #aaaaaa; border-right: 1px solid #aaaaaa; }
td.sourceCode { padding-left: 5px; }
pre, code { background-color: #f8f8f8; }
code > span.kw { color: #204a87; font-weight: bold; } /* Keyword */
code > span.dt { color: #204a87; } /* DataType */
code > span.dv { color: #0000cf; } /* DecVal */
code > span.bn { color: #0000cf; } /* BaseN */
code > span.fl { color: #0000cf; } /* Float */
code > span.ch { color: #4e9a06; } /* Char */
code > span.st { color: #4e9a06; } /* String */
code > span.co { color: #8f5902; font-style: italic; } /* Comment */
code > span.ot { color: #8f5902; } /* Other */
code > span.al { color: #ef2929; } /* Alert */
code > span.fu { color: #000000; } /* Function */
code > span.er { color: #a40000; font-weight: bold; } /* Error */
code > span.wa { color: #8f5902; font-weight: bold; font-style: italic; } /* Warning */
code > span.cn { color: #000000; } /* Constant */
code > span.sc { color: #000000; } /* SpecialChar */
code > span.vs { color: #4e9a06; } /* VerbatimString */
code > span.ss { color: #4e9a06; } /* SpecialString */
code > span.im { } /* Import */
code > span.va { color: #000000; } /* Variable */
code > span.cf { color: #204a87; font-weight: bold; } /* ControlFlow */
code > span.op { color: #ce5c00; font-weight: bold; } /* Operator */
code > span.pp { color: #8f5902; font-style: italic; } /* Preprocessor */
code > span.ex { } /* Extension */
code > span.at { color: #c4a000; } /* Attribute */
code > span.do { color: #8f5902; font-weight: bold; font-style: italic; } /* Documentation */
code > span.an { color: #8f5902; font-weight: bold; font-style: italic; } /* Annotation */
code > span.cv { color: #8f5902; font-weight: bold; font-style: italic; } /* CommentVar */
code > span.in { color: #8f5902; font-weight: bold; font-style: italic; } /* Information */
div.sourceCode {
  overflow-x: visible;
}
</style>
<style type="text/css">
  pre:not([class]) {
    background-color: white;
  }
</style>


<style type="text/css">
h1 {
  font-size: 34px;
}
h1.title {
  font-size: 38px;
}
h2 {
  font-size: 30px;
}
h3 {
  font-size: 24px;
}
h4 {
  font-size: 18px;
}
h5 {
  font-size: 16px;
}
h6 {
  font-size: 12px;
}
.table th:not([align]) {
  text-align: left;
}
</style>


</head>

<body>

<style type = "text/css">
.main-container {
  max-width: 940px;
  margin-left: auto;
  margin-right: auto;
}
code {
  color: inherit;
  background-color: rgba(0, 0, 0, 0.04);
}
img {
  max-width:100%;
  height: auto;
}
.tabbed-pane {
  padding-top: 12px;
}
.html-widget {
  margin-bottom: 20px;
}
button.code-folding-btn:focus {
  outline: none;
}
</style>



<div class="container-fluid main-container">

<!-- tabsets -->
<script>
$(document).ready(function () {
  window.buildTabsets("TOC");
});
</script>

<!-- code folding -->
<style type="text/css">
.code-folding-btn { margin-bottom: 4px; }
</style>
<script>
$(document).ready(function () {
  window.initializeCodeFolding("show" === "show");
});
</script>




<script>
$(document).ready(function ()  {

    // move toc-ignore selectors from section div to header
    $('div.section.toc-ignore')
        .removeClass('toc-ignore')
        .children('h1,h2,h3,h4,h5').addClass('toc-ignore');

    // establish options
    var options = {
      selectors: "h1,h2,h3",
      theme: "bootstrap3",
      context: '.toc-content',
      hashGenerator: function (text) {
        return text.replace(/[.\\/?&!#<>]/g, '').replace(/\s/g, '_').toLowerCase();
      },
      ignoreSelector: ".toc-ignore",
      scrollTo: 0
    };
    options.showAndHide = true;
    options.smoothScroll = true;

    // tocify
    var toc = $("#TOC").tocify(options).data("toc-tocify");
});
</script>

<style type="text/css">

#TOC {
  margin: 25px 0px 20px 0px;
}
@media (max-width: 768px) {
#TOC {
  position: relative;
  width: 100%;
}
}


.toc-content {
  padding-left: 30px;
  padding-right: 40px;
}

div.main-container {
  max-width: 1200px;
}

div.tocify {
  width: 20%;
  max-width: 260px;
  max-height: 85%;
}

@media (min-width: 768px) and (max-width: 991px) {
  div.tocify {
    width: 25%;
  }
}

@media (max-width: 767px) {
  div.tocify {
    width: 100%;
    max-width: none;
  }
}

.tocify ul, .tocify li {
  line-height: 20px;
}

.tocify-subheader .tocify-item {
  font-size: 0.90em;
  padding-left: 25px;
  text-indent: 0;
}

.tocify .list-group-item {
  border-radius: 0px;
}


</style>

<!-- setup 3col/9col grid for toc_float and main content  -->
<div class="row-fluid">
<div class="col-xs-12 col-sm-4 col-md-3">
<div id="TOC" class="tocify">
</div>
</div>

<div class="toc-content col-xs-12 col-sm-8 col-md-9">




<div class="fluid-row" id="header">

<div class="btn-group pull-right">
<button type="button" class="btn btn-default btn-xs dropdown-toggle" data-toggle="dropdown" aria-haspopup="true" aria-expanded="false"><span>Code</span> <span class="caret"></span></button>
<ul class="dropdown-menu" style="min-width: 50px;">
<li><a id="rmd-show-all-code" href="#">Show All Code</a></li>
<li><a id="rmd-hide-all-code" href="#">Hide All Code</a></li>
</ul>
</div>



<h1 class="title toc-ignore">关联规则</h1>

</div>


<div class="section level1">
<h1><span class="header-section-number">1</span> 关联规则简介</h1>
<p><font size=4 face="微软雅黑"></p>
<hr />
<p>  关联规则算法是数据挖掘中的一类重要的算法，1993年，R.Agrawal和R.Srikant等人首先提出关联规则概念，同时给出了相应的挖掘算法AIS，但是性能较差。1994年，他们建立了项目集格空间理论，并依据上述两个定理，提出了著名的Apriori算法，至今Apriori仍然作为关联规则挖掘的经典算法被广泛应用。</p>
<p>  Apriori算法之所以性能较高，是因为其实现了一个规则：<strong>一个项集如果不是频繁项集，其超项集也一定不是频繁项集</strong>，这个规则的限制会帮助算法大大减少对数据的遍历次数。</p>
<p>  关联规则是展现项集间关联与相关性的规则。关于这个算法有一个非常有名的故事：“尿布和啤酒”。故事是这样的：美国的妇女们经常会嘱咐她们的丈夫下班后为孩子买尿布，而丈夫在买完尿布后又要顺手买回自己爱喝的啤酒，因此啤酒和尿布在一起被购买的机会很多。这个举措使尿布和啤酒的销量双双增加，并一直为众商家所津津乐道。</p>
<p>  给大家展示一个典型的规则表达式：<strong>{啤酒，白酒}-&gt;{老醋花生}</strong></p>
<p>  上面的表达式很好理解，即如果某人购买了啤酒和白酒，那么其很有可能去购买老醋花生。根据这条规则，那么超市就可以把老醋花生放到啤酒和白酒附近的购物架上，促进销量。</p>
</div>
<div class="section level1">
<h1><span class="header-section-number">2</span> 关联规则的理解</h1>
<hr />
<p>  上面简单的介绍了一下关联规则，如果彻底理解关联规则则需要明白8个概念。那么下面我就给大家用理论加实际去讲解这8个概念：</p>
<p>  首先呢，我们先模拟一个简单的交易数据库，如下表所示:</p>
<table>
<thead>
<tr class="header">
<th align="center">交易号</th>
<th align="left">购物清单</th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td align="center">1</td>
<td align="left">{啤酒，白酒，香烟，老醋花生}</td>
</tr>
<tr class="even">
<td align="center">2</td>
<td align="left">{啤酒，白酒，老醋花生}</td>
</tr>
<tr class="odd">
<td align="center">3</td>
<td align="left">{啤酒，白酒，香烟}</td>
</tr>
<tr class="even">
<td align="center">4</td>
<td align="left">{啤酒，香烟}</td>
</tr>
<tr class="odd">
<td align="center">5</td>
<td align="left">{啤酒，牙膏}</td>
</tr>
<tr class="even">
<td align="center">6</td>
<td align="left">{白酒，暖壶}</td>
</tr>
<tr class="odd">
<td align="center">7</td>
<td align="left">{白酒，纸巾}</td>
</tr>
<tr class="even">
<td align="center">8</td>
<td align="left">{味精，食用盐}</td>
</tr>
</tbody>
</table>
<p><strong>项集：</strong></p>
<ul>
<li>概念：包含0个或多个项的集合被称为项集。</li>
<li>通俗理解：一次性购买商品的集合。</li>
<li>实例：{啤酒，白酒，老醋花生}</li>
</ul>
<p><strong>关联规则：</strong></p>
<ul>
<li>概念：形如X→Y的蕴涵式。</li>
<li>通俗理解：X与Y的关系表达式。</li>
<li>实例：{啤酒，白酒} —&gt; {老醋花生}</li>
</ul>
<p><strong>支持度：</strong></p>
<ul>
<li>概念：任何项集的组合在所有项集中出现的频率，通常用来删去无意义的规则。</li>
<li>通俗理解：同时购买X和Y的可能性。</li>
<li>实例：<strong>{啤酒}{白酒}</strong>在所有的项集中一共出现了3次，所以<strong>{啤酒}-&gt;{白酒}</strong>的支持度为<strong>3/9≈33.3%</strong>。</li>
<li>数学表达式为：<span class="math inline">\(support(X)=\frac{count(X)}{N}\)</span></li>
</ul>
<p><strong>置信度：</strong></p>
<ul>
<li>概念：Y在包含X的事务中出现的频繁程度，规则的预测能力的度量。</li>
<li>通俗理解：发生X的前提下也发生了Y的概率。</li>
<li>实例：<strong>{啤酒}</strong>出现了5次，<strong>{啤酒}</strong>和<strong>{白酒}</strong>同时出现了3次，所以<strong>{啤酒}-&gt;{白酒}</strong>的置信度为<strong>3/5=60%</strong>。</li>
<li>数学表达式：<span class="math inline">\(confidence(X \to Y)=\frac{support(X,Y)}{support(X)}\)</span></li>
</ul>
<p><strong>提升度：</strong></p>
<ul>
<li>概念：置信度与支持度的比值。是置信度的补充，提升度等于1时，X与Y是独立的；大于1时，越大说明X对Y的影响越大，即关联性越强。</li>
<li>通俗理解：出现X的条件下同时出现Y的可能性与没有任何条件下出现Y的可能性之比。</li>
<li>实例：<strong>{啤酒}</strong>和<strong>{白酒}</strong>的提升度为<strong>(3/5) / (3/9)=1.8</strong>。</li>
<li>数学表达式为：<span class="math inline">\(lift(X \to Y)=\frac{confidence(X \to Y)}{support(X)}\)</span></li>
</ul>
<p>  由于上面的那个模拟交易数据库不适合讲解下面的三个概念，所以重新模拟一个交易数据库：</p>
<table>
<thead>
<tr class="header">
<th align="center">交易号</th>
<th align="left">购物清单</th>
</tr>
</thead>
<tbody>
<tr class="odd">
<td align="center">1</td>
<td align="left">{啤酒，白酒，香烟，老醋花生}</td>
</tr>
<tr class="even">
<td align="center">2</td>
<td align="left">{啤酒，白酒，香烟}</td>
</tr>
<tr class="odd">
<td align="center">3</td>
<td align="left">{啤酒，白酒，香烟}</td>
</tr>
<tr class="even">
<td align="center">4</td>
<td align="left">{啤酒，香烟，老醋花生}</td>
</tr>
<tr class="odd">
<td align="center">5</td>
<td align="left">{啤酒，白酒}</td>
</tr>
<tr class="even">
<td align="center">6</td>
<td align="left">{啤酒，香烟}</td>
</tr>
</tbody>
</table>
<p><strong>频繁项集：</strong></p>
<ul>
<li>概念：支持度大于最小支持度阈值的项集</li>
<li>实例：假设支持度为2，因为<strong>{啤酒，香烟}</strong>出现了3次，所以其是频繁项集。</li>
</ul>
<p><strong>闭频繁项集：</strong></p>
<ul>
<li>概念：首先项集X为频繁项集，其次项集X与其超项集Y（X是Y的真子集）不具有相同的支持度。</li>
<li><p>实例：<strong>{啤酒，香烟}</strong>的超项集有<strong>{啤酒，白酒，香烟}</strong>、<strong>{啤酒，香烟，老醋花生}</strong>和<strong>{啤酒，白酒，香烟，老醋花生}</strong>，它们分别出现了2次、1次和1次，所以X与Y没有相同的支持度，即<strong>{啤酒，香烟}</strong>是闭频繁项集。</p></li>
<li><p><strong>最大频繁项集：</strong></p></li>
<li>概念：各频繁k-项集中符合无超集条件的频繁项集。</li>
<li><p>实例：<strong>{啤酒，白酒，香烟}</strong>出现了3次，属于频繁项集，其超项集<strong>{啤酒，白酒，香烟，老醋花生}</strong>出现了1次，故不是频繁项集，所以项集<strong>{啤酒，白酒，香烟}</strong>就是一个最大频繁项集。</p></li>
</ul>
<p>  到这里也就把这8个概念给大家介绍完了，下面就开始我们的案例实战部分了，同样案例实战也是一个购物篮的关联规则：</p>
</div>
<div class="section level1">
<h1><span class="header-section-number">3</span> 案例实战</h1>
<hr />
<p>  本案例的主要内容是利用1000多条的超市的消费数据去探索潜在的关联规则，从而为超市商品的摆放提供一些参考意见。</p>
<p>  在R中常用arules和arulesViz两个程序包去实现关联规则，第一个程序包提供了实现Apriori算法的函数，第二个程序包用于可视化关联规则，方便大家生动形象的理解产生的规则。</p>
<p><strong>apriori</strong></p>
<p>apriori(data, parameter = NULL, appearance = NULL, control = NULL)</p>
<ul>
<li><strong>data：</strong>含有交易数据的稀疏矩阵</li>
<li><strong>parameter：</strong>以列表的形式存储模型所需的支持度、置信度、每个项集所含项数的最大值/最小值和输出结果类型等参数，默认情况下支持度为0.1，置信度为0.8，项集中最大项数为10，最小项数为1，输出关联规则/频繁项集类型的结果。</li>
<li><strong>appearance：</strong>可为先决条件X和关联结果Y指定明确的项集(一般是分析人员感兴趣的项集)，默认情况下不为X和Y指定某些项集。</li>
<li><strong>control：</strong>用来控制函数性能，如对项集进行升序或降序，生成算法运行的报告进程等。</li>
</ul>
<div class="section level2">
<h2><span class="header-section-number">3.1</span> 获取并探索数据</h2>
<p>  本次数据读取的方式与之前有所不同，我们使用arules程序包中的<strong>read.transaction()</strong>函数读取数据，这样就可以成为<strong>apriori()</strong>函数所需要的数据类型。</p>
<p>read.transactions(file, sep = “”, …)</p>
<ul>
<li><strong>file：</strong>需要读取的数据</li>
<li><strong>sep：</strong>指定读取数据使用什么字符串分隔字段，默认为空字符串。</li>
</ul>
<div class="sourceCode"><pre class="sourceCode r"><code class="sourceCode r"><span class="co"># install.packages(&quot;dplyr&quot;)</span>
<span class="co"># install.packages(&quot;DT&quot;)</span>
<span class="co"># install.packages(&quot;arules&quot;)</span>
<span class="kw">library</span>(dplyr)
<span class="kw">library</span>(DT)
<span class="kw">library</span>(arules)

groceries &lt;-<span class="st"> </span><span class="kw">read.transactions</span>(<span class="dt">file =</span> <span class="kw">file.choose</span>(), <span class="dt">sep =</span> <span class="st">&quot;,&quot;</span>) <span class="co"># 读取数据</span>
<span class="kw">summary</span>(groceries)                                              <span class="co"># 查看数据集信息</span></code></pre></div>
<pre><code>## transactions as itemMatrix in sparse format with
##  1499 rows (elements/itemsets/transactions) and
##  38 columns (items) and a density of 0.2723746 
## 
## most frequent items:
## vegetables    poultry    waffles     bagels lunch meat    (Other) 
##        895        431        418        417        414      12940 
## 
## element (itemset/transaction) length distribution:
## sizes
##   3   4   5   6   7   8   9  10  11  12  13  14 
##   8  57  51  51  71  74  95 191 304 321 212  64 
## 
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##    3.00    9.00   11.00   10.35   12.00   14.00 
## 
## includes extended item information - examples:
##          labels
## 1  all- purpose
## 2 aluminum foil
## 3        bagels</code></pre>
<p>  下面我们首先看返回信息中的第一部分(如下所示)，其提供了我们创建的稀疏矩阵的概要：</p>
<ul>
<li><strong>1499 rows</strong>表示我们的交易数据的数量</li>
<li><strong>38 columns</strong>表示交易数据中一共出现了38中商品</li>
<li><strong>density of 0.27</strong>表示非零矩阵单元格的占比</li>
</ul>
<p><img src="summary_1.png" /> <br></p>
<p>  返回信息的第二部分(如下所示)，其提供了交易商品中最常购买的商品。最常购买的商品是vegetables，其次是poultry……</p>
<div class="figure">
<img src="summary_2.png" />

</div>
<p><br></p>
<p>  返回信息的第三部分(如下所示)，其提供了关于交易规模的统计。比如第一列的(3，8)表示在所有的交易中，有8次交易购买了3类商品；最后一列的(14，64)表示在所有的交易中，有64次交易购买了14类商品。从下面的主要描述性统计量中，我们可以快速的看出大约一半的交易商品数在11类左右。</p>
<div class="figure">
<img src="summary_2.png" />

</div>
<p><br></p>
<p>  综上所述，我们通过<strong>summary()</strong>函数返回的信息可以大体的了解交易数据的情况，但是并不能清洗的看到每一条交易的具体内容。要想查看每条交易的内容也很简单，在arules程序包中提供了<strong>inspect()</strong>函数，这样就可以快速查看自定义的交易内容：</p>
<div class="sourceCode"><pre class="sourceCode r"><code class="sourceCode r"><span class="kw">inspect</span>(groceries[<span class="kw">c</span>(<span class="dv">4</span>, <span class="dv">9</span>)]) <span class="co"># 查看第4、9次交易的内容</span></code></pre></div>
<pre><code>##     items                                            
## [1] {all- purpose,juice,lunch meat,soda,toilet paper}
## [2] {coffee/tea,dishwashing liquid/detergent,poultry}</code></pre>
<p>  到这里，我们的简单的数据探索就结束了。那么就有同学提出意见了，说老师说过探索数据的优先顺序不是图、表、文字吗，那么肯定是用图才能生动形象的描述数据啊。那么接下来我们就对数据进行一定的可视化，去帮助大家更加形象的了解数据：</p>
</div>
<div class="section level2 tabset tabset-fade tabset-pills">
<h2><span class="header-section-number">3.2</span> 可视化探索</h2>
<div id="itemfrequencyplot" class="section level3">
<h3><span class="header-section-number">3.2.1</span> itemFrequencyPlot()</h3>
<p><font size=4 face="微软雅黑"></p>
<p>  首先呢，我们先去可视化交易数据中大家经常购买的商品，去看看到底那些商品经常出现在大家的购物清单中，这样也可以间接的说明超市的这些商品最好不要缺货。在可视化商品交易频率时，我们使用的是arules程序包中提供的<strong>itemFrequencyPlot()</strong>函数。</p>
<div class="sourceCode"><pre class="sourceCode r"><code class="sourceCode r"><span class="co"># 绘制支持度最高的前十类商品，并按降序排列</span>
<span class="kw">itemFrequencyPlot</span>(groceries, <span class="dt">topN =</span> <span class="dv">10</span>)</code></pre></div>
<p><img src="1-apriori_files/figure-html/unnamed-chunk-3-1.png" width="672" /></p>
</div>
<div id="image" class="section level3">
<h3><span class="header-section-number">3.2.2</span> image()</h3>
<p><font size=4 face="微软雅黑"></p>
<p>  如果你想可视化交易数据的稀疏矩阵，可以使用arules程序包中提供的<strong>image()</strong>函数。该函数会返回一个矩阵图，该图中的黑点表明存在交易的记录(即该商品在此交易中被购买了)，空白的位置即没有交易的记录。</p>
<div class="sourceCode"><pre class="sourceCode r"><code class="sourceCode r"><span class="kw">image</span>(groceries[<span class="dv">1</span>:<span class="dv">10</span>, ]) <span class="co"># 可视化交易数据的稀疏矩阵</span></code></pre></div>
<p><img src="1-apriori_files/figure-html/unnamed-chunk-4-1.png" width="672" /></p>
</div>
</div>
<div class="section level2">
<h2><span class="header-section-number">3.3</span> 训练模型</h2>
<p>  现在已经把数据整理为了适用于apriori算法的类型，并且也对数据有了简答的了解。接下来我们就开始探寻购物车中商品之间的关联：</p>
<div class="sourceCode"><pre class="sourceCode r"><code class="sourceCode r">rules &lt;-<span class="st"> </span><span class="kw">apriori</span>(groceries, 
                 <span class="dt">parameter =</span> <span class="kw">list</span>(<span class="dt">minlen =</span> <span class="dv">2</span>,  <span class="co"># 规则的最低频数为2</span>
                                  <span class="dt">maxlen =</span> <span class="dv">4</span>,  <span class="co"># 规则的最高频数为4</span>
                                  <span class="dt">supp =</span> <span class="fl">0.01</span>, <span class="co"># 支持度设置为0.001</span>
                                  <span class="dt">conf =</span> <span class="fl">0.5</span>)) <span class="co"># 置信度设置为0.001</span></code></pre></div>
<pre><code>## Apriori
## 
## Parameter specification:
##  confidence minval smax arem  aval originalSupport maxtime support minlen
##         0.5    0.1    1 none FALSE            TRUE       5    0.01      2
##  maxlen target   ext
##       4  rules FALSE
## 
## Algorithmic control:
##  filter tree heap memopt load sort verbose
##     0.1 TRUE TRUE  FALSE TRUE    2    TRUE
## 
## Absolute minimum support count: 14 
## 
## set item appearances ...[0 item(s)] done [0.00s].
## set transactions ...[38 item(s), 1499 transaction(s)] done [0.00s].
## sorting and recoding items ... [38 item(s)] done [0.00s].
## creating transaction tree ... done [0.00s].
## checking subsets of size 1 2 3 4 done [0.01s].
## writing ... [4910 rule(s)] done [0.00s].
## creating S4 object  ... done [0.00s].</code></pre>
<div class="sourceCode"><pre class="sourceCode r"><code class="sourceCode r">rules</code></pre></div>
<pre><code>## set of 4910 rules</code></pre>
<p>  我们根据设置好的参数对数据构建关联规则，最后根据返回的结果得知共建立了4910条规则。下面我们可以根据自己的需求去筛选有用的规则。</p>
<p><strong>一般有三个需求：</strong></p>
<ul>
<li>更关注关联项集在总体中所占比重[根据支持度对规则进行降序排列]</li>
<li>更注重规则本身的可靠性[根据置信度对规则进行降序排列]</li>
<li>更关注关联规则的可靠性[根据提升度对规则进行降序排列]</li>
</ul>
<p>  我们首先观查一下前3个规则，然后假设我们更关注关联规则的可靠性，那么我们按照提升度对规则进行降序排列：</p>
<div class="sourceCode"><pre class="sourceCode r"><code class="sourceCode r"><span class="kw">inspect</span>(rules[<span class="dv">1</span>:<span class="dv">3</span>]) <span class="co"># 观察前三个规则</span></code></pre></div>
<pre><code>##     lhs            rhs          support   confidence lift     
## [1] {hand soap} =&gt; {vegetables} 0.1407605 0.5926966  0.9926841
## [2] {tortillas} =&gt; {vegetables} 0.1460974 0.5983607  1.0021705
## [3] {shampoo}   =&gt; {vegetables} 0.1454303 0.5860215  0.9815042</code></pre>
<div class="sourceCode"><pre class="sourceCode r"><code class="sourceCode r">rules2 &lt;-<span class="st"> </span><span class="kw">sort</span>(rules, <span class="dt">by =</span> <span class="st">&quot;lift&quot;</span>, <span class="dt">decreasing =</span> T) <span class="co"># 按照提升度对规则进行降序排列</span>
<span class="kw">inspect</span>(rules2[<span class="dv">1</span>:<span class="dv">5</span>])                               <span class="co"># 观察前五个规则</span></code></pre></div>
<pre><code>##     lhs                                     rhs               support   
## [1] {hand soap,individual meals,waffles} =&gt; {cheeses}         0.01000667
## [2] {aluminum foil,milk,sandwich loaves} =&gt; {tortillas}       0.01000667
## [3] {ice cream,paper towels,soda}        =&gt; {aluminum foil}   0.01000667
## [4] {paper towels,shampoo,soap}          =&gt; {sandwich loaves} 0.01000667
## [5] {bagels,beef,pasta}                  =&gt; {milk}            0.01000667
##     confidence lift    
## [1] 0.6250000  2.402244
## [2] 0.5555556  2.275349
## [3] 0.6000000  2.271212
## [4] 0.5555556  2.232648
## [5] 0.6000000  2.215271</code></pre>
<p>  返回结果的lhs和rhs所对应的列分别是规则的前项(触发规则需要的条件)和后项(满足触发条件的预期结果)。</p>
<p>  比如规则的第五条，用通俗的语言来讲就是：“如果某顾客购买了百吉饼、牛肉和意大利面，那么他还可能购买牛奶。”</p>
<ul>
<li>这条规则的支持度为0.01，即此种交易现象在所有的交易中出现的占比大约为1%</li>
<li>置信度为0.6，即前项出现的情况下，后项也发生的概率为60%</li>
<li>提升度为2.4，提升度大于1，即此规则的可靠性不错</li>
</ul>
<p>  上述规则看起来还是挺和谐的，但是咱们再看看第一条规则：“如果某顾客购买了香皂、单人餐和华夫饼，那么他还可能购买奶酪。”这样的规则看起来就令人费解了，这样的规则貌似没有一个合理的逻辑去解释，但是数据又为规则提供了一定的依据。为了解决这个问题，我们一般会把产生的规则分为3类：</p>
<ul>
<li>可行的规则[直接应用于市场]</li>
<li>平凡的规则[无需理会]</li>
<li>不明的规则[不采用或者作为尝试]</li>
</ul>
</div>
</div>
<div class="section level1">
<h1><span class="header-section-number">4</span> 总结</h1>
<hr />
<p>  关联规则是解决大数据问题的一种无监督学习的算法，它可以从任何关于模式的先验知识的大型数据库中提取知识。每中不足的是，将大量的信息缩减成更小、更容易于管理的结果集需要一些努力。本节研究的Apriori算法可以通过设置兴趣度的最小阈值和只呈现满足这些准则的关联来解决这个问题。</p>
<p>  还有一点就是现实中的数据是庞大的，很容易产生上亿的规则，这个规则的评估和检验依旧是一个很难解决的问题。</p>
</div>
<div class="section level1">
<h1><span class="header-section-number">5</span> 参考文献</h1>
<hr />
<p>[1] BrettLantz. 机器学习与R语言[M]. 机械工业出版社, 2015.<br> [2] 关联规则挖掘算法之Apriori算法.<a href="https://www.cnblogs.com/nxld/p/6380417.html" class="uri">https://www.cnblogs.com/nxld/p/6380417.html</a>. 2017.<br> [3] 基于R语言的关联规则实现.<a href="https://mp.weixin.qq.com/s?__biz=MzIxNjA2ODUzNg" class="uri">https://mp.weixin.qq.com/s?__biz=MzIxNjA2ODUzNg</a>==&amp;mid=400031158&amp;idx=1&amp;sn=2653f5711ab71d4a89be4287e60ba32e&amp;mpshare=1&amp;scene=23&amp;srcid=0618mZy2UVsGWjtV0vkqpYE5#rd.2015</p>
<p></font></p>
</div>



</div>
</div>

</div>

<script>

// add bootstrap table styles to pandoc tables
function bootstrapStylePandocTables() {
  $('tr.header').parent('thead').parent('table').addClass('table table-condensed');
}
$(document).ready(function () {
  bootstrapStylePandocTables();
});


</script>

<!-- dynamically load mathjax for compatibility with self-contained -->
<script>
  (function () {
    var script = document.createElement("script");
    script.type = "text/javascript";
    script.src  = "https://mathjax.rstudio.com/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML";
    document.getElementsByTagName("head")[0].appendChild(script);
  })();
</script>

</body>
</html>
